//:C16:OwnerStack.h
// Stack with runtime controllable ownership
#ifndef OWNERSTACK_H__
#define OWNERSTACK_H__

template<class T> 
class Stack
{
    struct Link
    {
        T *data;
        Link *next;
        Link(T *dat, Link *nxt) : data(dat), next(nxt){}
    }* head;
    bool own;
    public:
        Stack(bool own = true) : head(0), own(own){}
        ~Stack();
        void push(T *dat)
        {
            head = new Link(dat, head);
        }

        T *peek() const
        {
            return head ? head->data : 0;
        }

        T *pop();
        bool owns() const{ return own; }
        void owns(bool newownership)
        {
            own = newownership;
        }
        // Auto-type conversion: true if not empty: 
        operator bool() const{ return head != 0; }
};

template<class T> 
T *Stack<T>::pop()
{
    if(head == 0)
    {
        return 0;
    }

    T *result = head->data;
    Link *oldHead = head;
    head = head->next;
    delete oldHead;
    return result;
}

template<class T> 
Stack<T>::~Stack()
{
    if(!own)
    {
        return;
    }
    while(head)
    {
        delete pop();
    }
}
#endif
